{
"cells": [
{
"cell_type": "markdown",
"id": "f3768eba",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"# Getting Started with PauliwordOp"
]
},
{
"cell_type": "markdown",
"id": "09fc3eff-9766-4869-b97e-297f491ed7ca",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"The Pauli spin matrices $\\{X, Y, Z, I \\}$ are defined as:\n",
"\n",
"$$X = \\begin{bmatrix}\n",
"0 & 1\\\\ \n",
"1 & 0\n",
"\\end{bmatrix}$$\n",
"\n",
"$$Y = \\begin{bmatrix}\n",
"0 & -1i\\\\ \n",
"1i & 0\n",
"\\end{bmatrix}$$\n",
"\n",
"$$Z = \\begin{bmatrix}\n",
"1 & 0\\\\ \n",
"0 & -1\n",
"\\end{bmatrix}$$\n",
"\n",
"$$I = \\begin{bmatrix}\n",
"1 & 0\\\\\n",
"0 & 1\n",
"\\end{bmatrix}$$\n",
"\n",
"A Pauli operator $P_{i}$ is defined as an $n$-fold tensor products of such single qubit Pauli matrices. We can write this as:\n",
"\n",
"$$P_{i} = \\bigotimes_{k=0}^{n-1} \\sigma_{k} = \\sigma_{0} \\otimes \\sigma_{1} \\otimes ... \\otimes \\sigma_{n-1}$$\n",
"\n",
"where $\\sigma \\in \\{X, Y, Z, I \\}$ and the subscript $k$ indexes the qubit the Pauli matrix acts on.\n"
]
},
{
"cell_type": "markdown",
"id": "df1b548e-3fac-4e62-8f50-c74d6ced86c6",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"The `PauliwordOp` class is used to describe arbitrary linear combination of Pauli operators and provide useful manipulation functions."
]
},
{
"cell_type": "markdown",
"id": "6aa1b796-f746-417d-8ba3-cbb306aec601",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"## Initialization"
]
},
{
"cell_type": "markdown",
"id": "e15871ad-3dc0-44d8-93a4-de766fd1fbae",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"First we need to import `PauliwordOp`"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "b8b96530-dc5a-42af-8324-c99af619daa1",
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/Users/lex/anaconda3/envs/symmer_github/lib/python3.9/site-packages/cotengra/hyperoptimizers/hyper.py:34: UserWarning: Couldn't import `kahypar` - skipping from default hyper optimizer and using basic `labels` method instead.\n",
" warnings.warn(\n"
]
}
],
"source": [
"from symmer import PauliwordOp"
]
},
{
"cell_type": "markdown",
"id": "342e9dce-b578-4963-97c4-fd915fc1795c",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"We can then initialize a Pauli operator via the following methods:\n",
"1. `from_list`\n",
"2. `from_dictionary`\n",
"3. `from_matrix`\n",
"4. `random`\n",
"5. `haar_random`\n",
"6. `from_qiskit`\n",
"7. `from_openfermion`\n",
"8. `empty`"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "88499054",
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"text/plain": [
" 1.000+0.000j ZI +\n",
" 2.000+0.000j ZZ +\n",
" 3.000+0.000j ZX +\n",
" 4.000+0.000j YZ +\n",
" 5.000+0.000j XX +\n",
" 6.000+0.000j XY"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"term_list = ['ZI', 'ZZ', 'ZX', 'YZ', 'XX', 'XY']\n",
"coeffs = [1,2,3,4,5,6]\n",
"\n",
"PauliwordOp.from_list(term_list,\n",
" coeffs)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "eff541ba",
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"text/plain": [
" 1.000+0.000j ZI +\n",
" 2.000+0.000j ZZ +\n",
" 3.000+0.000j ZX +\n",
" 4.000+0.000j YZ +\n",
" 5.000+0.000j XX +\n",
" 6.000+0.000j XY"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"term_dict = {'ZI': (1+0j),\n",
" 'ZZ': (2+0j),\n",
" 'ZX': (3+0j),\n",
" 'YZ': (4+0j),\n",
" 'XX': (5+0j),\n",
" 'XY': (6+0j)}\n",
" \n",
"PauliwordOp.from_dictionary(term_dict)"
]
},
{
"cell_type": "markdown",
"id": "a757330e",
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"The `from_matrix` has two methods:\n",
"- projector: builds operator by matrix elements\n",
"- full_basis: builds operator by searching over basis of Pauli operators (size $4^{n}$)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "6e491a1a",
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"text/plain": [
" 1.000+0.000j ZI +\n",
" 2.000+0.000j ZZ +\n",
" 3.000+0.000j ZX +\n",
" 4.000+0.000j YZ +\n",
" 5.000+0.000j XX +\n",
" 6.000+0.000j XY"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import numpy as np\n",
"\n",
"mat = np.array([[ 3.+0.j, 3.+0.j, 0.-4.j, 5.-6.j],\n",
" [ 3.+0.j, -1.+0.j, 5.+6.j, 0.+4.j],\n",
" [ 0.+4.j, 5.-6.j, -3.+0.j, -3.+0.j],\n",
" [ 5.+6.j, 0.-4.j, -3.+0.j, 1.+0.j]])\n",
"\n",
"PauliwordOp.from_matrix(mat, \n",
" strategy='projector',\n",
" disable_loading_bar=True)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "ac1218be",
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "a051bf4d42e54228b8a0136036e7d79a",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Building operator via full basis: 0%| | 0/16 [00:00\n",
" (0, 0)\t(5+1j)\n",
" (0, 3)\t(1+0j)\n",
" (1, 1)\t(1-1j)\n",
" (1, 2)\t(1+0j)\n",
" (2, 1)\t(1+0j)\n",
" (2, 2)\t(1-1j)\n",
" (3, 0)\t(1+0j)\n",
" (3, 3)\t(5+1j)\n"
]
}
],
"source": [
"op_sparse_matrix = op.to_sparse_matrix\n",
"\n",
"print(type(op_sparse_matrix))\n",
"print(op_sparse_matrix)"
]
},
{
"cell_type": "markdown",
"id": "f25ff0a2",
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"We can use the `toarray` of `scipy.sparse._csr.csr_matrix` to make this a dense matrix"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "86b0ed7a",
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[5.+1.j 0.+0.j 0.+0.j 1.+0.j]\n",
" [0.+0.j 1.-1.j 1.+0.j 0.+0.j]\n",
" [0.+0.j 1.+0.j 1.-1.j 0.+0.j]\n",
" [1.+0.j 0.+0.j 0.+0.j 5.+1.j]]\n"
]
}
],
"source": [
"print(op_sparse_matrix.toarray())"
]
},
{
"cell_type": "markdown",
"id": "1c2a88b2",
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"We tabulate the operator into a pandas dataframe (`pandas.core.frame.DataFrame`)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "6bd2f698",
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" Pauli terms | \n",
" Coefficients (real) | \n",
" Coefficients (imaginary) | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" II | \n",
" 1.0 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 1 | \n",
" ZZ | \n",
" 2.0 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 2 | \n",
" XX | \n",
" 3.0 | \n",
" 0.0 | \n",
"
\n",
" \n",
"
\n",
"